import { FileTypeConfig, FileTypeManager } from '../config/file-types.config';
import { ITypeEntity } from '@/types/modules/superType/types';

/**
 * 注册新的文件类型
 * @param config 文件类型配置
 */
export function registerFileType(config: FileTypeConfig): void {
  const manager = FileTypeManager.getInstance();
  manager.register(config);
  
  console.log(`已注册文件类型: ${config.type} (${config.displayName})`);
}

/**
 * 批量注册文件类型
 * @param configs 文件类型配置数组
 */
export function registerFileTypes(configs: FileTypeConfig[]): void {
  configs.forEach(config => registerFileType(config));
}

/**
 * 创建简单的文件类型配置
 * @param type 文件类型
 * @param options 配置选项
 */
export function createSimpleFileTypeConfig(
  type: ITypeEntity['type'],
  options: {
    extension: string;
    displayName: string;
    icon?: string;
    defaultPath?: string;
    language?: string;
    editorComponent?: string;
    defaultTemplate?: string;
  }
): FileTypeConfig {
  return {
    type,
    extension: options.extension,
    displayName: options.displayName,
    icon: options.icon || 'FileOutlined',
    defaultPath: options.defaultPath || '/docs',
    language: options.language || 'text',
    editorComponent: options.editorComponent,
    defaultTemplate: options.defaultTemplate || '',
    versionControl: true,
    searchable: true,
  };
}

/**
 * 创建带验证器的文件类型配置
 * @param type 文件类型
 * @param options 配置选项
 * @param validator 验证函数
 */
export function createValidatedFileTypeConfig(
  type: ITypeEntity['type'],
  options: {
    extension: string;
    displayName: string;
    icon?: string;
    defaultPath?: string;
    language?: string;
    editorComponent?: string;
    defaultTemplate?: string;
    allowedPaths?: string[];
    forbiddenPaths?: string[];
  },
  validator: (content: string) => { valid: boolean; error?: string }
): FileTypeConfig {
  return {
    ...createSimpleFileTypeConfig(type, options),
    allowedPaths: options.allowedPaths,
    forbiddenPaths: options.forbiddenPaths,
    validator,
  };
}

/**
 * 预定义的文件类型配置模板
 */
export const FILE_TYPE_TEMPLATES = {
  /**
   * JSON 配置文件模板
   */
  jsonConfig: (type: ITypeEntity['type'], displayName: string) =>
    createValidatedFileTypeConfig(
      type,
      {
        extension: 'json',
        displayName,
        icon: 'FileTextOutlined',
        defaultPath: '/config',
        language: 'json',
        editorComponent: 'JsonEditor',
        defaultTemplate: '{}',
      },
      (content: string) => {
        try {
          JSON.parse(content);
          return { valid: true };
        } catch (error) {
          return { valid: false, error: '无效的 JSON 格式' };
        }
      }
    ),

  /**
   * YAML 配置文件模板
   */
  yamlConfig: (type: ITypeEntity['type'], displayName: string) =>
    createSimpleFileTypeConfig(type, {
      extension: 'yml',
      displayName,
      icon: 'FileTextOutlined',
      defaultPath: '/config',
      language: 'yaml',
      editorComponent: 'YamlEditor',
      defaultTemplate: '# YAML 配置文件\n',
    }),

  /**
   * 文档文件模板
   */
  documentFile: (type: ITypeEntity['type'], displayName: string, extension: string) =>
    createSimpleFileTypeConfig(type, {
      extension,
      displayName,
      icon: 'FileMarkdownOutlined',
      defaultPath: '/docs',
      language: 'markdown',
      editorComponent: 'MarkdownEditor',
      defaultTemplate: `# ${displayName}\n\n请在这里编写内容...\n`,
    }),

  /**
   * 脚本文件模板
   */
  scriptFile: (type: ITypeEntity['type'], displayName: string, language: string) =>
    createSimpleFileTypeConfig(type, {
      extension: language === 'typescript' ? 'ts' : 'js',
      displayName,
      icon: 'CodeOutlined',
      defaultPath: '/scripts',
      language,
      editorComponent: 'CodeEditor',
      defaultTemplate: `// ${displayName}\n\n`,
    }),

  /**
   * 数据文件模板
   */
  dataFile: (type: ITypeEntity['type'], displayName: string) =>
    createValidatedFileTypeConfig(
      type,
      {
        extension: 'json',
        displayName,
        icon: 'DatabaseOutlined',
        defaultPath: '/data',
        language: 'json',
        editorComponent: 'JsonEditor',
        defaultTemplate: '[]',
        forbiddenPaths: ['/apis', '/cloud_functions'],
      },
      (content: string) => {
        try {
          const data = JSON.parse(content);
          if (!Array.isArray(data) && typeof data !== 'object') {
            return { valid: false, error: '数据文件必须是数组或对象格式' };
          }
          return { valid: true };
        } catch (error) {
          return { valid: false, error: '无效的 JSON 格式' };
        }
      }
    ),
};

/**
 * 快速注册常用文件类型
 */
export function registerCommonFileTypes(): void {
  const commonTypes = [
    // 样式表文件
    createSimpleFileTypeConfig('code', {
      extension: 'css',
      displayName: '样式表',
      icon: 'BgColorsOutlined',
      defaultPath: '/styles',
      language: 'css',
      editorComponent: 'CssEditor',
      defaultTemplate: '/* 样式表 */\n\n',
    }),

    // SQL 文件
    createSimpleFileTypeConfig('code', {
      extension: 'sql',
      displayName: 'SQL 脚本',
      icon: 'DatabaseOutlined',
      defaultPath: '/sql',
      language: 'sql',
      editorComponent: 'SqlEditor',
      defaultTemplate: '-- SQL 脚本\n\n',
    }),

    // 环境配置文件
    FILE_TYPE_TEMPLATES.jsonConfig('config', '环境配置'),

    // 测试数据文件
    FILE_TYPE_TEMPLATES.dataFile('data', '测试数据'),
  ];

  registerFileTypes(commonTypes);
}

/**
 * 动态扩展现有文件类型
 * @param type 文件类型
 * @param extensions 扩展配置
 */
export function extendFileType(
  type: ITypeEntity['type'],
  extensions: Partial<FileTypeConfig>
): void {
  const manager = FileTypeManager.getInstance();
  const existingConfig = manager.getConfig(type);
  
  if (!existingConfig) {
    throw new Error(`文件类型 ${type} 不存在，无法扩展`);
  }

  const extendedConfig: FileTypeConfig = {
    ...existingConfig,
    ...extensions,
    // 合并数组类型的属性
    allowedPaths: extensions.allowedPaths || existingConfig.allowedPaths,
    forbiddenPaths: extensions.forbiddenPaths || existingConfig.forbiddenPaths,
    customProps: {
      ...existingConfig.customProps,
      ...extensions.customProps,
    },
  };

  manager.register(extendedConfig);
  console.log(`已扩展文件类型: ${type}`);
}

/**
 * 检查文件类型是否已注册
 * @param type 文件类型
 */
export function isFileTypeRegistered(type: ITypeEntity['type']): boolean {
  const manager = FileTypeManager.getInstance();
  return !!manager.getConfig(type);
}

/**
 * 获取所有已注册的文件类型
 */
export function getRegisteredFileTypes(): FileTypeConfig[] {
  const manager = FileTypeManager.getInstance();
  return manager.getAllTypes();
}

/**
 * 移除文件类型注册（谨慎使用）
 * @param type 文件类型
 */
export function unregisterFileType(type: ITypeEntity['type']): void {
  // 注意：这个功能需要在 FileTypeManager 中实现
  console.warn(`移除文件类型注册: ${type} (功能待实现)`);
}
